Mechanisms for built-in self repair of memory devices using failed bit maps and obvious repairs

ABSTRACT

A method of self-testing and self-repairing a random access memory (RAM) is includes collecting failure data of the RAM with redundant rows and columns, wherein the failure data of all failed cells of the RAM are stored in two failure bit map (FBM) data structures. The method further includes performing obvious repair of failed cells during the collecting of the failure data and analyzing the failure data in the two FBM data structure to determine repair methods. The method further includes repairing failed cells of the RAM by using the redundant rows and columns.

CLAIM OF PRIORITY

The present application is a continuation of U.S. application Ser. No. 13/291,620, filed Nov. 8, 2011, which claims the priority of U.S. Provisional Application No. 61/509,832, filed on Jul. 20, 2011, which are incorporated herein by reference in their entireties.

CROSS REFERENCES TO RELATED APPLICATIONS

The present application is related to U.S. application Ser. No. 13/291,747, filed Nov. 8, 2011, and U.S. application Ser. No. 13/291,707, filed Nov. 8, 2011, both of which are incorporated herein by reference in their entireties.

FIELD

The present disclosure relates generally to self-testing and self-repairing of memories.

BACKGROUND

Integrated circuits have become key components of many consumer and commercial electronic products, often replacing discrete components and enhancing functionality. The semiconductor processing technologies that produce these integrated circuits have advanced to the point wherein complete systems, including memories, can be reduced to a single integrated circuit, which can be an application specific integrated (ASIC) device or a system-on-a-chip (SOC) device.

Embedded random access memory (RAM) is among the most widely used cores in current ASIC or SOC implementations. Embedded RAM gives rise to problems during chip manufacturing. For example, because an embedded RAM occupies a significant portion of a chip's area, the probability that a defect lies within the RAM is relatively high. The RAM thus becomes a controlling factor in chip yield. In addition, the embedding of RAM not only makes its own testing difficult, but also impairs testability of all other functions on chip, such as the core logic.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A shows a memory array with redundant rows and columns, in accordance with some embodiments.

FIG. 1B shows a schematic diagram of a memory array with a built-in self-test-and-repair (BISTR) module, in accordance with some embodiments.

FIG. 2A shows a schematic diagram of a built-in self-test-and-repair (BISTR) module, in accordance with some other embodiments.

FIG. 2B shows a failure bit map (FBM) data structure, in accordance with some embodiments.

FIG. 2C shows another FBM data structure, in accordance with some embodiments.

FIGS. 3A and 3B show process flows of collecting data of failed cells of a main memory with obvious repairs, in accordance with some embodiments.

FIGS. 3C and 3D shows data in FBM data structures before and after obvious repairs, in accordance with some other embodiments.

FIG. 4A shows a process flow of repairing failed cells of the main memory, in accordance with some embodiments.

FIGS. 4B and 4C show how data in FBM data structures are used for determining a best candidate for repair, in accordance with some embodiments.

DETAILED DESCRIPTION

The following disclosure provides many different embodiments, or examples, for implementing different features of the disclosure. Specific examples of components and arrangements are described below to simplify the present disclosure. These are, of course, merely examples and are not intended to be limiting. In addition, the present disclosure may repeat reference numerals and/or letters in the various examples. This repetition is for the purpose of simplicity and clarity and does not in itself dictate a relationship between the various embodiments and/or configurations discussed.

As mentioned above, the defect concern in the embedded RAM makes testing necessary. In addition, the embedding of RAM not only makes its own testing difficult, but also impairs testability of all other functions on chip, such as the core logic. For example, much of the testing of other functions requires the use of the embedded RAM, which must be functioning properly. The RAM yield problems may be tackled by incorporating a repair scheme with redundant rows and/or columns. If an embedded memory is buried deeply within an ASIC or SOC device, built-in self-test (BIST) and built-in self-repair (BISR) have been used to assist memory repair. However, there are limitations of the existing BIST and BISR mechanisms to meet the requirement of memory repair for advanced devices.

FIG. 1A shows a memory array 100 with redundant rows and columns, in accordance with some embodiments. The memory array 100 could be a part of a memory chip or could be a part of an ASIC or SOC device. Memory array 100 includes a main memory 110, redundant rows 101 and redundant columns 102. The main memory 110 has M rows and N columns. M and N can be any integer number. The values of M and N determine the size of the main memory 110. For example, the main memory 110 may have 288 columns and 512 rows. Other numbers of columns and rows are also possible. In some embodiments, the main memory 110 may be further divided into a number of segments, such as 0 segments. 0 can be any integer number. In some embodiments, the segments are equal in size. For example, main memory 110 could have 8 segments, which are divided by columns. Using the exemplary main memory 110 described above, each segment has 36 columns if there are 288 columns and 8 segments. FIG. 1A shows that the main memory 110 has 0, 1, 2, . . . “O”−1 segments.

The redundant rows 101 and the redundant columns 102 are rows and columns of memory cells that are used for repairing failed cells in the main memory 110. In some embodiments, the redundant rows 101 are used for row repair and the redundant columns 102 are used for column repair. The numbers of redundant rows 101 and columns 102 depend on the size of main memory 110 and also on the manufacturing processes used to make main memory 110 and its size. Larger main memory 110 (with more rows and columns) may require more redundant rows and columns to assist in cell repair. In addition, if the processes used to manufacture the device have high yield, the numbers of redundant rows and columns could be lower. In contrast, if the processes have low yield, the numbers of redundant rows and columns needed would be higher. As shown in FIG. 1A, the main memory 110 has P redundant rows and Q redundant columns. P and Q are integers. P is smaller than M and Q is smaller than N, in accordance with some embodiments. For example, if there are 288 columns and 512 rows in main memory 110, there could be 16 redundant rows and 8 redundant columns. Other numbers of redundant rows or columns are also possible. In some embodiments, each redundant column is used to repair failed memory cell(s) in one designated segment. Under such circumstance, Q is equal to 0. The memory cell described here may refer to a memory unit, which may comprise a number of transistors.

FIG. 1B shows a schematic diagram of the memory array 100 with a built-in self-test-and-repair (BISTR) module 120, in accordance with some embodiments. The BISTR module 120 provides the functions of testing and repairing main memory 110. The BISTR module 120 includes a BIST module 130 for testing the main memory 110 and a BISR module 140 for repairing the main memory 110, in accordance with some embodiments. The BIST module 130 may include an address generator 131, which generates and provides address sequences to the main memory 110 during testing in accordance with some embodiments. The BIST module 130 may further includes a data generator 132, which generates and provides test data sequences to the main memory 110 during testing. The address sequences and the data sequences are generated in orders specified by a test pattern algorithm, in some embodiments. The data sequences may provide a set of data bits to detect various types of faults within the main memory 110. In addition, the BIST module 130 may include a test state controller 133, which provides inputs and control signals to the address generator 131 and the data generator 132. The test pattern algorithm described above may be generated by the test state controller 133. The BIST module 130 may scan the main memory 110 by row, by column, or a combination of both to test the entire main memory 110.

The BISR module 140 may analyze the received error (or failure) data generated from testing the main memory 110. The error (or failure) data may include an address(es) of the error(s) (or failed cells), also possibly along with the other received (or collected) error information, to determine the repair mechanism(s). Depending on the location and distribution of the error data, the repair could be done by row repair and/or column repair. The BISR module 140 may include a failure storage 141, which stores addresses of the failed memory cells. The failure storage 141 may also store the failure types associated with the failed memory cells. However, the storage of the failure types is not necessary.

The BISR module 140 may further include a repair controller 142 and a repair register 143. The repair controller 142 analyzes the failure data stored in failure storage 141 and determines the repair method(s), such as by row repair, by column repair, or by a combination of both. After the repair controller 142 determines the repair method(s), it issues a repair instruction to the repair register 143. The repair instruction may include the address(es) of row(s) and/or column(s) in the main memory 110 being repaired and the address(es) of redundant row(s) and/or redundant column(s) used for the repair(s). The repair register 143 then records the addresses received from the repair controller 142. When the memory array 100 is operated under read or write mode, the read/write address(es) is first checked against the repair addresses stored in the repair register 143 to see if the read/write address(es) is included in the repair register 143. If the answer is yes, the read/write would be performed on a correlated address(es) in the redundant row(s) or column(s) used for the repair.

The repair controller 142 may use a relatively simple “repair-on-the-go” algorithm to repair faulty memory cells. For example, the BISR module 140 may repair the detected failed memory cells as soon as they are discovered. As mentioned above, the BIST module 130 scans the main memory 110 and sends failure information to failure storage 141. The repair controller 142 may initiate repair based on the available failure data in the failure storage 141 before the scanning of the entire main memory 110 is completed. Such repair algorithm is relatively simple to implement and the failure storage 141 required is relatively small. For example, if the test sequences generated by the BIST module 130 identify a particular row of a failed cell, the failure location is sent to the failure storage 141. When the repair controller 142 detects such an error, the repair controller 142 could immediately initiate a row repair. Afterwards, the BISTR 120 continues with the scanning (and testing) and repairing of the remaining portion of the memory. One issue facing such a repair algorithm is that the repair methods used might not be ideal for the failure patterns of the main memory 110, because the repair method is determined based on limited failure data. For example, a row repair might have been used to repair a single error in a row before it is discovered that the column associated with one of the row failure has multiple failures. A column repair would have been a better choice. By using non-optimized or poor repair methods, the redundant rows and/or columns could run out before the entire main memory 110 is scanned. As a result, some failed cells might not be repaired due to lack of redundancy. The built-in self-test-and repair of the main memory 110 would then be deemed to have failed and the main memory 110 is marked as un-repairable. Therefore, the simple “repair-on-the-go” algorithm is not ideal.

FIG. 2A shows a schematic diagram of a built-in self-test-and-repair (BISTR) module 120′, in accordance with some embodiments. The BISTR module 120′ may be used to test and repair main memory 110 in a manner similar to the BISTR module 120 described above in many aspects. For example, the BIST module 130 in the BISTR module 120′ of FIG. 2A is similar to the memory BIST module 130 of FIG. 1B. However, the repair algorithm of BISR module 140′ is different from the repair algorithm of the BISR module 140 described above. The BIST module 140′ collects and analyzes one or more failure bit maps (FBMs), which store failure data of the entire main memory 110, before it determines the repair method(s). As shown in FIG. 2B, the BISR module 140′ includes a failure storage 141′, which includes a failure data converter 144 and a failure bit map (FBM) storage 145, in accordance with some embodiments. The failure data generated from BIST module 130 is stored in the FBM storage 145. To save the memory space required to save the entire main memory 110, the failure data stored in the FBM storage 145 are compressed failure data, which are generated (or converted) by the failure data converter 144 from failure data generated during the testing sequence of BIST 130.

The failure data stored in failure bit map (FBM) storage 145 are stored in bits. For example, if the main memory 110 has 288 columns with 8 segments, each segment has 36 columns, such as columns 0, 1, 2, . . . , 35. Six bits can be used to describe locations of 36 columns. FIG. 2B shows a FBM data structure 200, in accordance with some embodiments. The FBM data structure 200 includes “A” number of rows and “B” number of columns. A and B are both integers. Larger A and B allow storing more failure data with the down side of taking up extra memory space or additional real-estate on the chip. However, if the A and B are too small, it runs the risk of not being able to capture all failure data. In some embodiments, the A number is equal to or greater than the number of repair rows. The number B is equal to the number of repair column +1, in some embodiments. For example, the number A may be in a range from about 16 to about 50, and the number B may be in a range from about 8 to about 50.

For example, the FBM data structure 200 may has 28 rows and 9 columns. Using the example mentioned above with a main memory 110 having 288 columns and 8 segments, 8 out of the 9 columns are used to store error flags of failed cells in 8 segments. Each segment uses one of the 8 columns to record failure data in the segment. The extra column (the 9^(th) column) is used to store row addresses of failed cells, as shown in FIG. 2B in accordance with some embodiments. An error flag using “0” to represent no failure and “1” to represent a failure may be used. A single bit can be used to record failure or no-failure in a segment of a particular row. For example, an error flag in field 271 (or column 231 of row 201) is recorded with a “1” to reflect that there are one or more errors in a segment (segment 0) of a particular row. The memories used for such storage (single bit as error flag) are minimized. The row address of the error(s) in segment 0 is recorded in field 272 (or column 239 of row 201). The number of bits required to record the row address depends on the number of rows in the main memory 110. For example, if the main memory has 512 rows, 9 bits are needed to record the row address.

In addition to recording failures or no-failures in segments and rows, the locations (or address) of failed cells need to be recorded to enable repair. The FBM data structure 200 described above records the failed rows and segments. However, the FBM data structure 200 does not record the column addresses of failed cells. Therefore, another data structure, data structure 250, is used to record the column addresses of failed cells. Data structures 200 and 250 are used together to enable the determination of repair method and the repair work.

FIG. 2C shows data structure 250 for storing column addresses of failed cells, in accordance with some embodiments. For example, FBM data structure 250 may have 9 rows and 8 columns. The column addresses of failed cells are represented by column indexes, represented by bits. If the main memory 110 has 288 columns with 8 segments, each segment has 36 columns, such as columns 0, 1, 2, . . . , 35. 6 bits can be used to describe locations of 36 columns. FIG. 2C shows that the column address data structure 250 has C rows and B−1 columns, in accordance with some embodiments. C is an integer. The column address data structure 250 has one fewer column than data structure 200, because the column for recording the row addresses is not needed. For example, data structure 250 may have 9 rows and 8 columns. Each column is assigned to record column addresses of an assigned segment. For example, column 261 of data structure 250 is assigned to record column addresses of failed cells in segment 0, column 262 of data structure 250 is assigned to record column addresses of failed cells in segment 1, etc. In some embodiments, C is equal to A. However, C may be larger or smaller than A.

The FBM data structures 200 and 250 are populated by the failure test results generated by BIST module 130. Once the failure data start to be collected, or the failure bit maps (FBMs) start to be populated, the repair controller 142′ is initiated to analyze the failure data to determine “obvious” repair candidates. Obvious repair candidates refer to failures whose repair methods can be clearly defined without ambiguity before completed collection of data on FBMs, or without complete failure data. For example, if a new error causes a segment violation, the new error can only be fixed by a redundant row. The need of fixing errors having segment violation(s) does not change with additional collection of failure data. Therefore, it is “obvious” that the row that has segment violation needs to be repaired by a redundant row. If the row is repaired right after the row has a segment violation, or new data causing the row to have the segment violation, the remaining un-tested portion of the row can be saved from further testing. As a result, the time and resources, such as storage space, needed for testing the remaining portion of the row and for storing failure results can be saved.

FIG. 3A shows a process flow 300 of collecting (or populating) failed bit map (FBM) data and performing some obvious repair of a main memory, in accordance with some embodiments. At operation 301, main memory 110 is scanned and tested to find (or identify, or locate) failed cells. The memory cells of main memory 110 may be scanned by rows, by columns, or by a combination of rows and columns to identify failed memory cells. The failure locations are stored in data structures, such as data structures 200 and 250. Once the data structures start to be populated, an obvious repair candidate(s) can be identified at operation 302. Once the obvious repair candidate is identified, process flow 300 proceeds to operation 303. At operation 303, a decision is made regarding whether redundancy is available to make the obvious repair. If there is a redundant row/column for the repair, the obvious repair is performed at operation 304. The repair work may include registering the addresses of repaired column(s) and/or row(s) and the addresses of redundancy used, such as in repair register 143. When the main memory is under usage, the control module that accesses the main memory, such as main memory 110, would check the repair register to determine which rows and/or columns have been repaired and where the redundancy rows and/or columns are. Otherwise, the self test and repair have failed and process flow 300 proceeds to operation 307.

After repair is performed at operation 304, process flow 300 proceeds to operation 305, where a decision of whether main memory is fully tested. Not every single memory cell in the main memory 110 needs to be tested. The untested portions of rows and columns that are repaired with redundant rows and columns do not need to be tested, since they are removed from usage. If the testing of main memory 110 has been completed, process flow will then proceed to operation 306, where the main memory 110 is recorded as being fully tested with obvious repairs completed. The failure data collected can then be further analyzed to determine repair methods and to make repair, if sufficient redundant rows and/or columns are available. If the main memory 110 has not been fully tested, process flow 300 returns from operation 305 to operation 301 for additional testing.

FIG. 3B shows a process flow 310 of testing and repairing collecting a main memory by using a built-in self-test-repair (BISTR) module on a chip, in accordance with some embodiments. In this process flow, a number of exemplary conditions for obvious repair are added in the process flow to describe the testing and repair process. One exemplary condition for an obvious row repair is segment violation. When there are more than one failed columns in a segment of a particular row, the row is said to have a segment violation. As mentioned above, each segment is only assigned a redundant column for repair. If there are more than one failed columns, the repair can only be fixed by row repair. Another possible condition is to set limits on numbers of failures in rows and/or columns. When the number of failures of a particular row exceeds the set limit, row repair is considered necessary. For example, a row failure limit can be set at 4. If there are equal to or greater than 4 failures in a row, the row is considered to have too many failures and repair by a redundant row is considered necessary to repair a significant number of failures from the row. Similar limit can be set for columns. The limits should not be set too low to make the repair methods qualified as obvious.

Process flow 310 starts at operation 311, where the main memory 110 is scanned and tested to find (or identify) failed cells. Once failed cells are identified, a decision of whether the failed cells belong to new rows (i.e. not existing in the data structure) is made at operation 312. If the failed cells do not belong to new rows, the failure data are saved at operation 310. Saving the failure data involves storing the new row address and the row information in data structures 200 and 250. Afterwards, process flow 310 proceeds to operation 326, which will be described below.

If the failed cells belong to new rows, process flow 310 moves to the next operation 313 of determining whether there is a segment violation(s) of the row. When there is more than one failed column in a segment of a particular row, the row is said to have a segment violation. As mentioned above, each segment is only assigned a redundant column for repair. If there is more than one failed column, the repair can only be fixed by row repair.

If there is a segment violation, a decision as to whether a redundant row is available is made at operation 315. If there is no redundant row available, the BISR is considered to have failed at operation 325. If BISR has failed, the BISTR module could take actions to terminate all activities relate to the built-in self test and repair (BISTR).

If it is discovered that there is a redundant row available at operation 315, process flow 310 proceeds to operation 317 of performing row repair. After row repair, the data of the repaired row are cleared from the data structures that are used to store failure information, such as data structures 200 and 250, at operation 318. Afterwards, process flow 310 proceeds to operation 326 of determining if all memory cells have been tested. If the answer is yes, the collection of failure data is considered finished at operation 327. The collection of the failure data is accompanied with obvious repairs. If the answer is no for the question at operation 326, process flow 310 returns to operation 311 to continue scanning and testing the untested portion of the main memory. As mentioned above, the untested portion of rows or columns that have been repaired need not be tested.

If it is determined that there is no segment violation at operation 313, process flow 310 proceeds to operation 319. At operation 319, a decision of whether the number of failures of the rows for the newly identified failed cells is equal to or greater than the row limit is made. As mentioned above, the row limit is defined to be the limit of the number of failures of row for row repair. For example, if the row limit is 5 failures, a row that has failures equal to or greater than about 5 would be repaired by row repair. Similar definition is also made for column limit. Is the decision to the question at operation 319 is “yes,” the process flow proceeds to operation 315 to determine whether there is a redundant row for the row repair. The process following operation 315 has been described above. If the number of row fails is smaller than the row limit, process flow proceeds to operation 320, which checks whether there are obvious column repair candidates. If column fails are equal to or greater than the column limit for the decision at operation 320, process flow continues to operation 321, where the availability of the redundant column is checked. If a redundant column(s) is available, repair is performed at operation 322. After the column repair is performed at operation 322, the failure data of the repaired column are cleared from the data structure at operation 323. If it is determined at operation 321 that there is no redundant column available to repair the column identified as an obvious candidate for column repair, the BISR has failed and process flow 310 proceeds to operation 325.

If it is determined at operation 320 that the column fails do not meet the criteria of obvious repair, the process flow 310 continues to operation 324. At operation 324, the failure data are saved (or stored). The failure data are saved in data structures 200 and 250. Operation 324 is followed by operation 326, which has been described above.

FIGS. 1C and 1D show a number of exemplary data in data structures 200 and 250 during the testing and repairing process, in accordance with some embodiments. Table 330 of FIG. 1C shows data structure 200 after collecting some failure data. Table 330 shows that that there are 6 rows that have failed cells. Column 339 shows the addresses of rows that have failures. The addresses are represented by 9 bits. As described above, if the main memory has 512 rows, 9 bits are needed to record the row address. Columns 331-338 are used to indicate whether there are errors in each of the 8 segments. An indicator 0 means there is no error in the segment and an indicator 1 means there is at least one error in the segment. The locations of columns that have failed cells are recorded in data structure 250. An example of such a data structure is table 350, which will be described in more details below. During the testing and obvious repairing process, such as process described in FIGS. 3A and 3B, a new failure has been identified in row 000000111. This new failure is in segment 0, represented by column 331 in Table 330, which already has one failure, as indicated by the “1” in field 388 of Table 330. As a result, the new failure causes segment 0 to have segment violation. As mentioned above, when a row suffers from segment violation, the only method to repair the failures is by row repair. Therefore, a row repair is performed, such as in operation 317 of FIG. 3B. Table 340 shows that after the row repair is performed, the data of row 000000111 is cleared, as shown in row 341. In the example here, row 341 is kept with other fields cleared. However, the entire row 341 may be deleted and the row that has been repaired can have its row address (000000111) registered in another to storage or table.

Table 350 shows data in structure 250 that corresponds to data in Table 340, in accordance with some embodiments. Table 350 has 8 columns and data in each column describe the failure column in a particular segment. For example, the 3 in field 351 indicate that column 3 in segment 0 has a failed cell. The failed cell is in row 000000011 because Table 340 shows a “1” in field 342. Another example is the field 359 of Table 350. Field 359 shows that column 10 of segment 7 has a failure, which correlates to field 343 of Table 340, and the failure is in row 000001000.

Table 360 shows another exemplary table of failure data and the corresponding failure column locations are in table 370 as shown in FIG. 3D. As shown in table 370, there are two errors in column 10 of segment 7. In this example, the column limit for obvious column repair is 3. As a result, when another failure is found in column 10 of segment 7, a column repair is performed. After the repair is performed, the failure data are cleared from the data structures. Table 390 shows that the failure data of row 000001001 are cleared. Table 380 also shows that the addresses of repaired column 10 are removed from the table after the repair.

The discussion and examples described above show that by identifying and performing obvious repair, the time and resources for testing can be saved. Because, the rows and columns that have been repaired for obvious reasons do not need to be tested further. The reduction in testing also saves the storage resources needed. With reduced testing, the failure data would be fewer. Therefore, the storage resources can be reduced. The repaired rows and columns can be recorded as having no failures in the FBMs.

After the failure data are collected, such as according to the process flows 300 and 310 described above, the failures that have not been repaired by obvious repair need to be repaired. FIG. 4A shows a process flow 400 of repairing the remaining failures after the collection of data in FBMs, or failure data in the data structures, of the entire main memory, in accordance with some embodiments. The process flow continues from operation 306 of FIG. 3A or operation 327 of FIG. 3B. Process flow 400 starts at operation 401 of analyzing the failure data collected. After the failure data are analyzed, a decision of whether all error flags are gone is made at operation 402. If all failures are gone, the BISR is considered successful and the process continues to operation 403, where the main memory is recorded as being successfully tested and repaired. If some error flags still exist, process flow moves to operation 404, wherein a decision of whether all redundancy is used is made. If all the redundancy is used, the BISR has failed and is recorded at operation 405. If there is still redundancy, process flow 400 proceeds to the next operation, which is operation 406, which is the part of a decision and repair loop to identify candidates for column repair and/or best column repair candidates.

The decision and repair loop examines each segment until all segments have been reviewed. At operation 406, a decision of whether segment redundancy is available is made for the segment under study. If segment redundancy is available, process flow 400 proceeds to the next operation 407, where a determination of whether the segment under study has only one error at the next operation 407. If the segment has only one error, column repair is performed on the segment at operation 408. Otherwise, a column with the most failures is identified as the best column repair candidate for the segment at operation 409. Operations 408 and 409 are followed by operation 410, where a decision of whether the segment under study is the last segment of the decision and repair loop is made. If the segment is the last segment, which means that every segment has been evaluated, process flow 400 proceeds to operation 411. Otherwise, process flow loops back to operation 406 to analyze and/or repair the next segment.

At operation 411, the availability of row redundancy is evaluated. If there is no row redundancy, the only possible repair mechanism is column repair. As a result, the next operation 412 with no redundancy is operation 412, where the availability of column redundancy is checked. If there is not column redundancy, the self repair has failed and the failure is reflected at operation 405, since the failure(s) cannot be repaired. If there is column redundancy, the failure(s) is repaired by redundant column(s) at operation 413. Afterwards, the data of the repaired column is cleared at operation 414, which continues to operation 401.

If it is determined at operation 411 that row redundancy is available, process flow 400 proceeds to operation 415, where the failure data are analyzed to determine best row repair candidate (or a row with most failures). Afterwards, a decision of whether there are more errors in the column candidate (determined at operation 419) or more errors in the row candidate (determined at operation 415) is made at operation 416. If there are more errors in the column, then column repair is performed at operation 413. Otherwise, row repair is performed at operation 417. As described above, operation 413 proceeds to operation 414. As shown in FIG. 4A, operation 417 also proceeds to operation 414, where the data of the repaired row is cleared.

Process flow 400 show how unrepaired column and/or row failures (or errors) can be repaired, in accordance with some embodiments. Operation 416 described above compares numbers of errors in a column and in a row to determine whether to conduct column repair or row repair. FIG. 4B shows exemplary data in data structures (or tables), which are used to perform the comparison. FIG. 4B shows the Tables 340′ and 350′. Table 350′ correlates to Table 340′. In the example shown in FIG. 4B, the column limit is higher than 3 or there is no column list. As a result, there are 3 errors in column 10 of segment 7. Table 350′ is analyzed to identify a column with a maximum number of errors. FIG. 4B shows that the segment data in Table 350 are reduced to 4 segment Tables 431, 432, 433, and 434. Table 431 includes errors in segment 7. The data in Table 431 includes 1 error in column 33, 1 error in column 21, and 3 errors in column 10. Table 432 shows an error in column 13 of segment 3. Table 433 shows 1 error in column 9 of segment 1 and Table 434 shows 1 error in column 3 of segment 0. The results show that column 10 in segment 7 has the highest number of errors (3). As a result, column 10 of segment 7 is considered the best candidate for column repair at operation 409.

The results in FIG. 4B show that by comparing the data in tables (or summaries) reduced from the data structures shown in FIGS. 2B and 2C, the address of the column (column 10 of segment 7) with the maximum number of errors can be identified, in accordance with some embodiments. However, the formation of Tables 431-434 is not necessary in getting such a conclusion. Algorithms without using such tables may also be used to reach such a conclusion. The operation that produces such analysis and result is operation 412 described above.

FIG. 4C shows the failure data of Table 340′ after it has been reduced to a table 440 with reduced row addresses, in accordance with some embodiments. Table 440 shows that each of rows 1, 8, 9, and 10 has 1 error. Table 440 also shows that rows 2 and 3 both have 2 errors. As a result, the row that has the highest errors is either row 2 (or row 000000010) or row 3 (or row 000000011). Either one can be selected as the best candidate for row repair. For discussion purpose, row 2 is chosen to be the best candidate for row repair at operation 415. Based on results above, the best column repair candidate has higher number of failures (3) than the best candidate for row repair, which has 2 failures, at operation 416. As a result process flow proceeds to operation 413, where column 10 of segment 7 is repaired by a redundant column.

The end result of method 400 is either a completely repaired main memory 110 or a non-repairable main memory 110. In some embodiments, the non-repairable main memory 110 is marked as a lower-grade memory with the addresses of un-repaired rows and/or columns recorded, if there are not too many of them, and can still be sold or used.

The embodiments of mechanisms described may be used to self-test and self-repair any type of RAM, including volatile and non-volatile memories, such as static RAM (SRAM), dynamic RAM (DRAM), or flash memory, etc. The built-in self repair analysis circuit is configurable (parameterizable) to support different sizes and configurations of memories. The repair solutions can be designed to optimize repair efficiency for memories with different sizes and configurations for different test time specifications and different available areas (for test and/or repair devices) on chips. Although the examples described above involve a redundant column for a segment, more than one redundant column may be reserved for a particular segment. When this occurs, the repair methods need to be adjusted accordingly. For example, the criteria of segment violation would be different with the number of columns with failures in a segment adjusted accordingly. Alternatively, rows can also be divided into segments and redundant rows can be assigned to dedicated segments.

The failure bit map (FBM) data and built-in-self-test-repair (BISTR) module described above enable collecting and analyzing FBM data of the entire memory to identify the best repairing method (or mechanism) to make repairs. By performing obvious repairs during collection of the FBM data, testing and date storage resources can be saved. As a result, the repair method is better and more efficient than algorithms (or method) known to the inventors, which only utilize partial (or incomplete) failure data. The compressed data structures used for the FBMs keep the resources used to capture the FBM data and to repair the failed cells relatively limited.

In some embodiments, a method of self-testing and self-repairing a random access memory (RAM) is provided. The method includes collecting failure data of the RAM with redundant rows and columns, wherein the failure data of all failed cells of the RAM are stored in two failure bit map (FBM) data structures. The method further includes performing obvious repair of failed cells during the collecting of the failure data and analyzing the failure data in the two FBM data structure to determine repair methods. The method further includes repairing failed cells of the RAM by using the redundant rows and columns.

In some other embodiments, a method of using a random access memory (RAM) having self-testing and self-repairing capabilities, the RAM having a plurality of rows and a plurality of columns is provided. The method includes repairing at least one row of the RAM or at least one column of the RAM. Repairing the at least one row of the RAM or the at least one column of the RAM includes collecting failure data of the RAM with redundant rows and columns, wherein the failure data of all failed cells of the RAM are stored in two failure bit map (FBM) data structures. Repairing the at least one row of the RAM or the at least one column of the RAM further includes performing obvious repair of failed cells during the collecting of the failure data and analyzing the failure data in the two FBM data structure to determine repair methods. Repairing the at least one row of the RAM or the at least one column of the RAM further includes repairing failed cells of the RAM by using the redundant rows and columns and registering repaired cells in a repair register. The method further includes checking a repair register to determine which row of the plurality of rows or which column of the plurality of columns have been repaired.

In yet some other embodiments, a memory array with a built-in self-test (BIST) module and a built-in self-repair (BISR) module to repair a main memory of the memory array. The memory array includes a first number of redundant rows for row repair of the main memory and a second number of redundant columns for column repair of the main memory. The memory array further includes the BIST module for testing the main memory. The memory array further includes the BISR module for repairing the main memory by using the redundant rows and redundant columns, wherein the BISR module performs obvious repair during testing of the main memory, and wherein the BISR instructs the BIST to stop testing untested portion of columns and rows repaired by obvious repairs, and wherein the BISR module performs other repairs based on failure bit maps (FBMs) generated from testing the entire main memory.

While the preceding description shows and describes one or more embodiments, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the present disclosure. Therefore, the claims should be interpreted in a broad manner, consistent with the present disclosure. 

What is claimed is:
 1. A method of self-testing and self-repairing a random access memory (RAM), comprising: collecting failure data of the RAM with redundant rows and columns, wherein the failure data of all failed cells of the RAM are stored in two failure bit map (FBM) data structures; performing obvious repair of failed cells during the collecting of the failure data; analyzing the failure data in the two FBM data structure to determine repair methods; and repairing failed cells of the RAM by using the redundant rows and columns.
 2. The method of claim 1, further comprising: determining whether the RAM is fully tested; and recording the RAM as fully tested with obvious repairs done if the RAM is fully tested.
 3. The method of claim 2, wherein determining whether the RAM is fully tested comprises: determining the RAM to be fully tested if less than an entirety of a first row is tested if an obvious repair was performed on the first row.
 4. The method of claim 1, further comprising: determining whether a redundant memory is full; and reporting a failure of the self-repairing if the redundant memory is full.
 5. The method of claim 4, wherein determining whether the redundant memory is full occurs prior to performing obvious repair of failed cells.
 6. The method of claim 1, further comprising registering the obvious repair in a repair register following performing the obvious repair.
 7. A method of using a random access memory (RAM) having self-testing and self-repairing capabilities, the RAM having a plurality of rows and a plurality of columns, the method comprising: repairing at least one row of the RAM or at least one column of the RAM, wherein repairing the at least one row of the RAM or the at least one column of the RAM comprises: collecting failure data of the RAM with redundant rows and columns, wherein the failure data of all failed cells of the RAM are stored in two failure bit map (FBM) data structures; performing obvious repair of failed cells during the collecting of the failure data; analyzing the failure data in the two FBM data structure to determine repair methods; repairing failed cells of the RAM by using the redundant rows and columns; and registering repaired cells in a repair register; checking a repair register to determine which row of the plurality of rows or which column of the plurality of columns has been repaired.
 8. The method of claim 7, wherein repairing at least one row of the RAM or at least one column of the RAM further comprising: determining whether the RAM is fully tested; and recording the RAM as fully tested with obvious repairs done if the RAM is fully tested.
 9. The method of claim 8, wherein determining whether the RAM is fully tested comprises: determining the RAM to be fully tested if less than an entirety of a first row is tested if an obvious repair was performed on the first row.
 10. The method of claim 7, wherein repairing at least one row of the RAM or at least one column of the RAM further comprising: determining whether a redundant memory is full; and reporting a failure of the self-repairing if the redundant memory is full.
 11. The method of claim 10, wherein determining whether the redundant memory is full occurs prior to performing obvious repair of failed cells.
 12. A memory array with a built-in self-test (BIST) module and a built-in self-repair (BISR) module to repair a main memory of the memory array, comprising: a first number of redundant rows for row repair of the main memory; a second number of redundant columns for column repair of the main memory; the BIST module for testing the main memory; and the BISR module for repairing the main memory by using the redundant rows and redundant columns, wherein the BISR module performs obvious repair during testing of the main memory, and wherein the BISR instructs the BIST to stop testing untested portion of columns and rows repaired by obvious repairs, and wherein the BISR module performs other repairs based on failure bit maps (FBMs) generated from testing the entire main memory.
 13. The memory array of claim 12, wherein the failure bit maps comprises: a first failure bit map having A rows and B columns, where A is an integer greater than 1 and B is an integer greater than 1; and a second failure bit map having C rows and B−1 columns, where C is an integer greater than
 1. 14. The memory array of claim 13, wherein A is equal to C.
 15. The memory array of claim 13, wherein B is one greater than the second number.
 16. The memory array of claim 13, wherein the first failure bit map is configured to store error flags in columns 1 through B−1, and to store a row address of failed cells in column B.
 17. The memory array of claim 13, wherein the second failure bit map is configured to store column addresses of failed cells.
 18. The memory array of claim 12, wherein the BISR comprises: a failure storage module for storing failure data received from the BIST module; a repair controller for determining a repair method based on the failure data received from the BIST module, the repair controller further for issuing repair instructions; and a repair register or storing repair instructions from the repair controller.
 19. The memory array of claim 18, wherein the failure storage further comprises: a failure data converter for compressing failure data received from the BIST module; and the FBMs for storing the compressed failure data.
 20. The memory array of claim 12, wherein the BIST module comprises: an address generator configured to generate addresses for testing the RAM; a data generator for generating test data for testing the RAM; and a test state controller for controlling the address generator and the data generator. 